home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d913.lha / AssignPrefs / Source / AssignPrefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-04  |  17.2 KB  |  695 lines
  1. /*-- AutoRev header do NOT edit!
  2. *
  3. *   Program        :    AssignPrefs.c
  4. *   Copyright        :    © 1993 by Digital Dimensions
  5. *   Author        :    Thomas Frieden
  6. *   Creation Date   :    14-Jul-93
  7. *   Current version :    1.02
  8. *   Translator        :    AztecC
  9. *
  10. *   REVISION HISTORY
  11. *
  12. *   Date      Version      Comment
  13. *   ---------      -------      ------------------------------------------
  14. *   14-Jul-93      0.0          First version
  15. *   30-Jul-93      0.1          Working editor, to do assigning and icon
  16. *   31-Jul-93      1.0          Omega version, icon stuff included
  17. *   31-Jul-93      1.01          Minor bug fixes
  18. *   31-Jul-93      1.02          Major bug fixes
  19. *
  20. *-- REV_END --*/
  21.  
  22. #include "globals.h"
  23. #include "gadgets.h"
  24.  
  25. #define PNAME        "AssignPrefs V1.02"
  26. #define PRINT(x)    if (wb) ShowRequest(x,"OK"); else printf("%s\n",x)
  27.  
  28.  
  29. char version[] = "$VER: AssignPrefs 1.02";
  30. char defname[256] = "envarc:assignprefs";
  31. char fname[256];
  32. char FileName[256];
  33. char printme[256];
  34. char Name[256];
  35. char Path[256];
  36. char *Types[] = {"Locked", "Path", "Add", "Late"};
  37. LONG parse[3];
  38. BYTE  AssType = 0;
  39. BOOL  SaveIcons = TRUE, wb = FALSE;
  40. struct List AssignList;
  41. struct AssignNode {
  42.     struct Node an_Node;
  43.     char    an_Name[256];
  44.     char    an_Path[256];
  45. };
  46. struct AssignNode *akt, *cnode;
  47. extern struct DiskObject *def_assign;
  48. char *NodeName;
  49.  
  50.  
  51. struct IntuitionBase    *IntuitionBase;
  52. struct GfxBase        *GfxBase;
  53. struct Library        *GadToolsBase;
  54. struct Library        *UtilityBase;
  55. struct Library        *AslBase;
  56. struct Library        *DiskfontBase;
  57. struct Library        *IconBase;
  58.  
  59. void    CloseAll() {
  60.  
  61.     CloseMainWindow();
  62.     CloseDownScreen();
  63.     if (IntuitionBase)        CloseLibrary((struct Library *)IntuitionBase);
  64.     if (GfxBase)        CloseLibrary((struct Library *)GfxBase);
  65.     if (GadToolsBase)        CloseLibrary(           GadToolsBase);
  66.     if (UtilityBase)        CloseLibrary(           UtilityBase);
  67.     if (AslBase)        CloseLibrary(           AslBase);
  68.     if (DiskfontBase)        CloseLibrary(           DiskfontBase);
  69.     if (IconBase)        CloseLibrary(           IconBase);
  70. }
  71.  
  72.  
  73.  
  74.  
  75. void    OpenAll() {
  76.  
  77.     IntuitionBase = (struct IntuitionBase *)
  78.             OpenLibrary((APTR)"intuition.library",37L);
  79.  
  80.     if (!IntuitionBase) {
  81.     printf("Need OS2.0 to run \n");
  82.     CloseAll();
  83.     exit(30);
  84.     }
  85.  
  86.     GfxBase      = (struct GfxBase *)
  87.             OpenLibrary((APTR)"graphics.library",0);
  88.     GadToolsBase  = OpenLibrary((APTR)"gadtools.library",0);
  89.     UtilityBase      = OpenLibrary((APTR)"utility.library",0);
  90.     AslBase      = OpenLibrary((APTR)"asl.library",0);
  91.     DiskfontBase  = OpenLibrary((APTR)"diskfont.library",0);
  92.     IconBase      = OpenLibrary((APTR)"icon.library",0);
  93. }
  94.  
  95.  
  96. long ShowRequest(char *text, char *gads) {
  97.     struct EasyStruct es;
  98.     es.es_StructSize=sizeof(struct EasyStruct);
  99.     es.es_Flags=0;
  100.     es.es_Title=(UBYTE *)PNAME " © 1993 Digital Dimensions";
  101.     es.es_TextFormat=(UBYTE *)text;
  102.     es.es_GadgetFormat=(UBYTE *)gads;
  103.     return EasyRequestArgs(NULL,&es,NULL,NULL);
  104. }
  105.  
  106.  
  107. BOOL FileRequest(BOOL dironly, BOOL Save) {
  108.  
  109.     struct FileRequester *request;
  110.     BOOL result;
  111.     static char dir[256] = "";
  112.  
  113.     if (!dironly) {
  114.     if (Save)
  115.         request=(struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  116.         ASL_Hail,    "Select file to save... ",
  117.         ASL_Window,    MainWnd,
  118.         ASL_FuncFlags,    FILF_SAVE,
  119.         ASL_Dir,    dir,
  120.         TAG_DONE);
  121.     else
  122.         request=(struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  123.         ASL_Hail,    "Select file to open...",
  124.         ASL_Window,    MainWnd,
  125.         ASL_Dir,    dir,
  126.         TAG_DONE);
  127.     } else {
  128.     request=(struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  129.         ASL_Hail,        "Select directory to assign...",
  130.         ASL_Window,        MainWnd,
  131.         ASL_ExtFlags1,  FIL1F_NOFILES,
  132.         ASL_Dir,        dir,
  133.         TAG_DONE);
  134.     }
  135.  
  136.     if (request==NULL)
  137.     return(FALSE);
  138.     result = AslRequest(request,NULL);
  139.     if (result==FALSE) {
  140.     FreeAslRequest(request);
  141.     return FALSE;
  142.     }
  143.     strncpy(FileName,(char *)(request->rf_Dir),256);
  144.     strncpy(dir,(char *)(request->rf_Dir),256);
  145.     if (!dironly) AddPart((STRPTR)FileName,request->rf_File,256);
  146.     FreeAslRequest(request);
  147.     return(TRUE);
  148. }
  149.  
  150.  
  151. struct AssignNode *NewNode() {
  152.     return(AllocVec(sizeof(struct AssignNode),MEMF_CLEAR|MEMF_PUBLIC));
  153. }
  154.  
  155.  
  156. void FreeList() {
  157.  
  158.     struct AssignNode *nnode;
  159.  
  160.     nnode = (struct AssignNode *)1L;
  161.     while (nnode) {
  162.     nnode = (struct AssignNode *)RemHead(&AssignList);
  163.     if (nnode) {
  164.         FreeVec(nnode->an_Node.ln_Name);
  165.         FreeVec(nnode);
  166.     }
  167.     }
  168. }
  169.  
  170. void AssList() {
  171.  
  172.     struct AssignNode *nnode;
  173.     BPTR lock;
  174.     char printme[256];
  175.  
  176.     nnode = (struct AssignNode *)1L;
  177.     while (nnode) {
  178.     nnode = (struct AssignNode *)RemHead(&AssignList);
  179.     if (nnode) {
  180.         switch(nnode->an_Node.ln_Pri) {
  181.         case    0:    if (lock = Lock((STRPTR)nnode->an_Path, SHARED_LOCK)) {
  182.                 if (!(AssignLock((STRPTR)nnode->an_Name,lock))) {
  183.                 sprintf(printme,"Error assigning %s", nnode->an_Name);
  184.                 PRINT(printme);
  185.                 }
  186.             } else {
  187.                 sprintf(printme,"Cannot Lock %s",nnode->an_Path);
  188.                 PRINT(printme);
  189.             }
  190.             break;
  191.         case    1:    if (!(AssignPath((STRPTR)nnode->an_Name,(STRPTR)nnode->an_Path))) {
  192.                 sprintf(printme,"Error assigning %s", nnode->an_Name);
  193.                 PRINT(printme);
  194.             }
  195.             break;
  196.         case    2:    if (lock = Lock((STRPTR)nnode->an_Path, SHARED_LOCK)) {
  197.                 if (!(AssignAdd((STRPTR)nnode->an_Name,lock))) {
  198.                 sprintf(printme,"Error assigning %s", nnode->an_Name);
  199.                 PRINT(printme);
  200.                 }
  201.             } else {
  202.                 sprintf(printme,"Cannot Lock %s", nnode->an_Path);
  203.                 PRINT(printme);
  204.             }
  205.             break;
  206.         case    3:    if (!(AssignLate((STRPTR)nnode->an_Name, (STRPTR)nnode->an_Path))) {
  207.                 sprintf(printme, "Error assigning %s", nnode->an_Name);
  208.                 PRINT(printme);
  209.             }
  210.             break;
  211.         }
  212.         FreeVec(nnode->an_Node.ln_Name);
  213.         FreeVec(nnode);
  214.     }
  215.     }
  216. }
  217.  
  218.  
  219. void AddNode(BOOL Update) {
  220.     if (strlen(Name) != 0) {
  221.     if (!cnode) {
  222.         if (strlen(Path)==0) {
  223.         FileRequest(TRUE,FALSE);
  224.         strcpy(Path,FileName);
  225.         }
  226.         akt = NewNode();
  227.         NodeName = AllocVec(80,MEMF_CLEAR|MEMF_PUBLIC);
  228.         sprintf(NodeName,"%20.20s: %-32.32s - %s", Name, Path, Types[AssType]);
  229.         akt->an_Node.ln_Name = NodeName;
  230.         akt->an_Node.ln_Pri = (BYTE)AssType;
  231.         strcpy(akt->an_Name,Name);
  232.         strcpy(akt->an_Path,Path);
  233.         AddTail(&AssignList,(struct Node *)akt);
  234.         if (Update) {
  235.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_List], MainWnd, NULL,
  236.             GTLV_Labels,    &AssignList,
  237.             TAG_DONE);
  238.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssName], MainWnd, NULL,
  239.             GTST_String,   (ULONG)"",
  240.             TAG_DONE);
  241.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_Path], MainWnd, NULL,
  242.             GTST_String,    (ULONG)"",
  243.             TAG_DONE);
  244.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssType], MainWnd, NULL,
  245.             GTCY_Active,    0,
  246.             TAG_DONE);
  247.         }
  248.         AssType = 0;
  249.         strcpy(Path,"");
  250.         strcpy(Name,"");
  251.     } else {
  252.         sprintf(cnode->an_Node.ln_Name,
  253.         "%20.20s: %-32.32s - %s", Name, Path,   
  254.         Types[AssType]);
  255.         cnode->an_Node.ln_Pri = (BYTE)AssType;
  256.         strcpy(cnode->an_Name,Name);
  257.         strcpy(cnode->an_Path,Path);
  258.         if (Update) {
  259.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_List], MainWnd, NULL,
  260.             GTLV_Labels,    &AssignList,
  261.             TAG_DONE);
  262.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssName], MainWnd, NULL,
  263.             GTST_String,   (ULONG)"",
  264.             TAG_DONE);
  265.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_Path], MainWnd, NULL,
  266.             GTST_String,    (ULONG)"",
  267.             TAG_DONE);
  268.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssType], MainWnd, NULL,
  269.             GTCY_Active,    0,
  270.             TAG_DONE);
  271.         }
  272.         AssType = 0;
  273.         strcpy(Path,"");
  274.         strcpy(Name,"");
  275.         cnode=NULL;
  276.     }
  277.     } else {
  278.     ActivateGadget(MainGadgets[GDX_ap_AssName], MainWnd, NULL);
  279.     }
  280. }
  281.  
  282. void DelNode() {
  283.  
  284.     if (cnode) {
  285.     Remove((struct Node *)cnode);
  286.     FreeVec(cnode->an_Node.ln_Name);
  287.     FreeVec(cnode);
  288.     GT_SetGadgetAttrs(MainGadgets[GDX_ap_List], MainWnd, NULL,
  289.         GTLV_Labels,    &AssignList,
  290.         TAG_DONE);
  291.     GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssName], MainWnd, NULL,
  292.         GTST_String,   (ULONG)"",
  293.         TAG_DONE);
  294.     GT_SetGadgetAttrs(MainGadgets[GDX_ap_Path], MainWnd, NULL,
  295.         GTST_String,    (ULONG)"",
  296.         TAG_DONE);
  297.     GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssType], MainWnd, NULL,
  298.         GTCY_Active,    0,
  299.         TAG_DONE);
  300.     AssType = 0;
  301.     strcpy(Name,"");
  302.     strcpy(Path,"");
  303.  
  304.     }
  305.     cnode = 0L;
  306. }
  307.  
  308. void LoadList(char *name, BOOL show) {
  309.  
  310.     BPTR fh;
  311.     ULONG len;
  312.     LONG Type,*t;
  313.     struct AssignNode *anode;
  314.     char buffer[1024];
  315.     char st[81];
  316.     struct RDArgs *par,*ap;
  317.  
  318.     par = (struct RDArgs *)AllocDosObject(DOS_RDARGS,TAG_DONE);
  319.     if (!par) {
  320.     PRINT("Error in AllocDosObject");
  321.     return;
  322.     }
  323.     fh = Open((STRPTR)name, MODE_OLDFILE);
  324.     if (!fh)
  325.     return;
  326.  
  327.     while (TRUE) {
  328.     if (!(FGets(fh,(STRPTR)&buffer,1024))) break;
  329.     par->RDA_Flags |= RDAF_NOPROMPT;
  330.     par->RDA_Source.CS_Buffer = (UBYTE *)&buffer;
  331.     par->RDA_Source.CS_Length = strlen(buffer);
  332.     par->RDA_Source.CS_CurChr = 0L;
  333.     ap = ReadArgs((STRPTR)"Name/K/A,Path/K/A,Type/N/A",(LONG *)parse,par);
  334.     if (!ap) {
  335.         PRINT("Error in AssignPrefs file. Wrong format!");
  336.         Close(fh);
  337.         FreeList();
  338.         if (show)
  339.         GT_SetGadgetAttrs(MainGadgets[GDX_ap_List], MainWnd, NULL,
  340.             GTLV_Labels,    &AssignList,
  341.             TAG_DONE);
  342.         return;
  343.     }
  344.     strcpy(Name,(char *)parse[0]);
  345.     strcpy(Path,(char *)parse[1]);
  346.     t = (LONG *)parse[2];
  347.     Type = *t;
  348.     anode = AllocVec(sizeof(struct AssignNode),MEMF_CLEAR);
  349.     anode->an_Node.ln_Name = AllocVec(90,MEMF_CLEAR);
  350.     strcpy(anode->an_Name,Name);
  351.     strcpy(anode->an_Path,Path);
  352.     anode->an_Node.ln_Pri = (BYTE)Type;
  353.     AddTail(&AssignList,(struct Node *)anode);
  354.     FreeArgs(ap);
  355.     }
  356.  
  357.     Close(fh);
  358.     FreeDosObject(DOS_RDARGS,par);
  359.  
  360.     anode = (struct AssignNode *)AssignList.lh_Head;
  361.     while (anode->an_Node.ln_Succ) {
  362.     sprintf(st,"%20.20s: %-32.32s - %s", anode->an_Name, anode->an_Path,   
  363.         Types[anode->an_Node.ln_Pri]);
  364.     strcpy(anode->an_Node.ln_Name,st);
  365.     anode = (struct AssignNode *)anode->an_Node.ln_Succ;
  366.     }
  367.  
  368.     strcpy(Name,"");
  369.     strcpy(Path,"");
  370.     if (show) GT_SetGadgetAttrs(MainGadgets[GDX_ap_List], MainWnd, NULL,
  371.         GTLV_Labels,    &AssignList,
  372.         TAG_DONE);
  373. }
  374.  
  375.  
  376. void SaveIcon(char *name) {
  377.  
  378.     struct DiskObject *dob;
  379.     BOOL FreeMe = TRUE;
  380.  
  381.     dob = (struct DiskObject *)GetDiskObject((char *)"env:sys/def_assign");
  382.     if (dob == NULL) {
  383.     dob = (struct DiskObject *)&def_assign;
  384.     FreeMe = FALSE;
  385.     }
  386.     if (!(PutDiskObject((STRPTR)name,dob)))
  387.     ShowRequest("Error writing Icon","OK");
  388.     if (FreeMe) FreeDiskObject(dob);
  389. }
  390.  
  391.  
  392. void SaveList(char *name) {
  393.  
  394.     BPTR fh;
  395.     ULONG len;
  396.     struct AssignNode *anode;
  397.     char buffer[1024];
  398.  
  399.     fh = Open((STRPTR)name, MODE_NEWFILE);
  400.     anode = (struct AssignNode *)(AssignList.lh_Head);
  401.  
  402.     while (anode->an_Node.ln_Succ) {
  403.     sprintf(buffer,"Name=%s Path=\"%s\" Type=%d\n",anode->an_Name,anode->an_Path,anode->an_Node.ln_Pri);
  404.     len = Write(fh,&buffer,strlen(buffer));
  405.     if (len != strlen(buffer)) {
  406.         ShowRequest("Error writing file","OK");
  407.         Close(fh);
  408.         return;
  409.     }
  410.     anode = (struct AssignNode *)anode->an_Node.ln_Succ;
  411.     }
  412.     Close(fh);
  413.     if (SaveIcons) SaveIcon(name);
  414. }
  415.  
  416.  
  417. BOOL ProcessMenu(USHORT Code) {
  418.  
  419.     UWORD mm,ss,ii;
  420.     BOOL running = TRUE;
  421.  
  422.     mm = MENUNUM(Code);
  423.     ii = ITEMNUM(Code);
  424.     ss = SUBNUM(Code);
  425.  
  426.     switch(mm) {
  427.     case 0: switch(ii) {
  428.         case 0: if (!(FileRequest(FALSE,FALSE))) break;
  429.             FreeList();
  430.             LoadList(FileName,TRUE);
  431.             break;
  432.         case 1: if (!(FileRequest(FALSE,FALSE))) break;
  433.             LoadList(FileName,TRUE);
  434.             break;
  435.         case 2: if (!(FileRequest(FALSE,TRUE))) break;
  436.             SaveList(FileName);
  437.             break;
  438.         case 4: ShowRequest("AssignPrefs V1.0\n© 1993 by DIgital DImensions\n"
  439.                 "Written by Thomas Frieden\n\nFor bug reports and Questions write to:\n"
  440.                 "Thomas Frieden\nSchlossstr. 176\n54293 Trier\n"
  441.                 "email: inf02@uni-trier.de","Great, man");
  442.             break;
  443.         case 6: running = FALSE;
  444.             break;
  445.     }
  446.     break;
  447.     case 1: switch(ii) {
  448.         case 0: FreeList();
  449.             LoadList(defname,TRUE);
  450.             break;
  451.     }
  452.     break;
  453.     case 2: switch(ii) {
  454.         case 0: SaveIcons = !SaveIcons;
  455.             break;
  456.     }
  457.     break;
  458.     }
  459.  
  460.     return(running);
  461. }
  462.  
  463.  
  464. void main(int argc, char **argv) {
  465.  
  466.     struct IntuiMessage *imsg;
  467.     ULONG Class;
  468.     USHORT Code;
  469.     SHORT Id,i;
  470.     BOOL running = TRUE;
  471.     BOOL use = FALSE;
  472.     BPTR lock,oldlock;
  473.     struct RDArgs *ap;
  474.     struct WBStartup *wbs;
  475.     struct WBArg *wba;
  476.     struct DiskObject *dob;
  477.     UBYTE **ta, *s;
  478.  
  479.  
  480.     if (argc != 0) {
  481.     wb = FALSE;
  482.     ap = ReadArgs((APTR)"FILE,USE/S",parse,NULL);
  483.     if (!ap) {
  484.         FreeArgs(ap);
  485.         PrintFault(IoErr(),NULL);
  486.         CloseAll();
  487.         exit(IoErr());
  488.     } else {
  489.         FreeArgs(ap);
  490.         if (parse[0]) strcpy(fname,(char *)parse[0]);
  491.         if (parse[1]) use = TRUE;
  492.     }
  493.     }
  494.  
  495.     if (use) {
  496.     if (strlen(fname) == 0)
  497.         strcpy(fname,defname);
  498.     NewList(&AssignList);
  499.     LoadList(fname,FALSE);
  500.     AssList();
  501.     CloseAll();
  502.     exit(0);
  503.     }
  504.  
  505.     OpenAll();
  506.  
  507.     if (argc == 0) {
  508.     wb = TRUE;
  509.     wbs = (struct WBStartup *)argv;
  510.     wba = wbs->sm_ArgList;
  511.     if (wbs->sm_NumArgs > 1) {
  512.         NameFromLock(wba[1].wa_Lock,(STRPTR)fname,256);
  513.         AddPart((STRPTR)fname,(STRPTR)wba[1].wa_Name,256);
  514.         oldlock = CurrentDir(wba[1].wa_Lock);
  515.         dob = (struct DiskObject *)GetDiskObject(wba[1].wa_Name);
  516.         CurrentDir(oldlock);
  517.         if (dob) {
  518.         if (dob->do_ToolTypes) {
  519.             ta = (UBYTE **)dob->do_ToolTypes;
  520.             if (s = (UBYTE *)FindToolType((char **)ta,"ACTION")) {
  521.             if (MatchToolValue(s,(UBYTE *)"USE"))       use = TRUE;
  522.             if (MatchToolValue(s,(UBYTE *)"use"))       use = TRUE;
  523.             if (MatchToolValue(s,(UBYTE *)"POPUP"))     use = FALSE;
  524.             if (MatchToolValue(s,(UBYTE *)"popup"))     use = FALSE;
  525.             }
  526.         }
  527.         }
  528.     } else {
  529.         oldlock = CurrentDir(wba->wa_Lock);
  530.         dob = (struct DiskObject *)GetDiskObject(wba->wa_Name);
  531.         CurrentDir(oldlock);
  532.         if (dob) {
  533.         if (dob->do_ToolTypes) {
  534.             ta = (UBYTE **)dob->do_ToolTypes;
  535.             if (s = (UBYTE *)FindToolType((char **)ta,"ACTION")) {
  536.             if (MatchToolValue(s,(UBYTE *)"USE"))    use = TRUE;
  537.             if (MatchToolValue(s,(UBYTE *)"use"))    use = TRUE;
  538.             if (MatchToolValue(s,(UBYTE *)"POPUP"))  use = FALSE;
  539.             if (MatchToolValue(s,(UBYTE *)"popup"))  use = FALSE;
  540.             }
  541.             if (s = (UBYTE *)FindToolType((char **)ta,"FILE")) strcpy(defname, (char *)s);
  542.         }
  543.         FreeDiskObject(dob);
  544.         };
  545.     }
  546.     }
  547.  
  548.     if (strlen(fname) == 0)
  549.     strcpy(fname,defname);
  550.  
  551.     if (use) {
  552.     NewList(&AssignList);
  553.     LoadList(fname,FALSE);
  554.     AssList();
  555.     CloseAll();
  556.     exit(0);
  557.     }
  558.  
  559.     SetupScreen();
  560.     OpenMainWindow();
  561.  
  562.     NewList(&AssignList);
  563.     cnode = NULL;
  564.  
  565.     LoadList(fname,TRUE);
  566.  
  567.     while(running) {
  568.     WaitPort(MainWnd->UserPort);
  569.     while(imsg = GT_GetIMsg(MainWnd->UserPort)) {
  570.         Class = imsg->Class;
  571.         Code  = imsg->Code;
  572.         if (Class == IDCMP_GADGETUP || Class == IDCMP_GADGETDOWN)
  573.         Id = ((struct Gadget *)(imsg->IAddress))->GadgetID;
  574.         GT_ReplyIMsg(imsg);
  575.         switch(Class) {
  576.         case IDCMP_MENUPICK:
  577.         running = ProcessMenu(Code);
  578.         break;
  579.         case IDCMP_VANILLAKEY:
  580.         switch(Code) {
  581.         case    'a':
  582.         case    'A':
  583.             AddNode(TRUE);
  584.             break;
  585.         case    'q':
  586.         case    'Q':
  587.             running = FALSE;
  588.             break;
  589.         case    'n':
  590.         case    'N':
  591.             ActivateGadget(MainGadgets[GDX_ap_AssName], MainWnd, NULL);
  592.             break;
  593.         case    'p':
  594.         case    'P':
  595.             ActivateGadget(MainGadgets[GDX_ap_Path], MainWnd, NULL);
  596.             break;
  597.         case    't':
  598.             AssType++;
  599.             AssType = AssType & 3;
  600.             GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssType], MainWnd, NULL,
  601.                 GTCY_Active,    AssType,
  602.                 TAG_DONE);
  603.             break;
  604.         case    'T':
  605.             AssType--;
  606.             AssType = AssType & 3;
  607.             GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssType], MainWnd, NULL,
  608.                 GTCY_Active,    AssType,
  609.                 TAG_DONE);
  610.             break;
  611.  
  612.         case    'd':
  613.         case    'D':
  614.             DelNode();
  615.             break;
  616.         case    's':
  617.         case    'S':
  618.             SaveList(defname);
  619.             break;
  620.         }
  621.         break;
  622.         case IDCMP_REFRESHWINDOW:
  623.         GT_BeginRefresh(MainWnd);
  624.         GT_EndRefresh(MainWnd,TRUE);
  625.         break;
  626.         case    IDCMP_GADGETUP:
  627.         switch(Id) {
  628.         case    GD_ap_Cancel:
  629.             running = FALSE;
  630.             break;
  631.         case    GD_ap_AssName:
  632.             strcpy(Name, (char *)GetString(MainGadgets[GDX_ap_AssName]));
  633.             ActivateGadget(MainGadgets[GDX_ap_Path],MainWnd,NULL);
  634.             break;
  635.         case    GD_ap_Path:
  636.             strcpy(Path, (char *)GetString(MainGadgets[GDX_ap_Path]));
  637.             if (strlen(Path)==0) {
  638.             if (FileRequest(TRUE,FALSE)) {
  639.                 strcpy(Path,FileName);
  640.                 if (strlen(Path) == 0) {
  641.                 lock = Lock((STRPTR)"Ram:",SHARED_LOCK);
  642.                 oldlock = CurrentDir(lock);
  643.                 NameFromLock(oldlock,(STRPTR)Path,256);
  644.                 CurrentDir(oldlock);
  645.                 UnLock(lock);
  646.                 }
  647.                 GT_SetGadgetAttrs(MainGadgets[GDX_ap_Path], MainWnd, NULL,
  648.                 GTST_String,    Path,
  649.                 TAG_DONE);
  650.             }
  651.             }
  652.             break;
  653.         case    GD_ap_AssType:
  654.             AssType = Code;
  655.             break;
  656.         case    GD_ap_List:
  657.             cnode = (struct AssignNode *)AssignList.lh_Head;
  658.             for (i=0;i<Code;i++)
  659.             cnode=(struct AssignNode *)cnode->an_Node.ln_Succ;
  660.             GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssName], MainWnd, NULL,
  661.                 GTST_String,    (ULONG)cnode->an_Name,
  662.                 TAG_DONE);
  663.             GT_SetGadgetAttrs(MainGadgets[GDX_ap_Path], MainWnd, NULL,
  664.                 GTST_String,    (ULONG)cnode->an_Path,
  665.                 TAG_DONE);
  666.             GT_SetGadgetAttrs(MainGadgets[GDX_ap_AssType], MainWnd, NULL,
  667.                 GTCY_Active,    (ULONG)cnode->an_Node.ln_Pri,
  668.                 TAG_DONE);
  669.             strcpy(Name, cnode->an_Name);
  670.             strcpy(Path, cnode->an_Path);
  671.             AssType = cnode->an_Node.ln_Pri;
  672.             break;
  673.         case    GD_ap_Add:
  674.             AddNode(TRUE);
  675.             break;
  676.         case    GD_ap_Del:
  677.             DelNode();
  678.             break;
  679.         case    GD_ap_Save:
  680.             SaveList(defname);
  681.             break;
  682.         }
  683.         break;
  684.         }
  685.     }
  686.     }
  687.     FreeList();
  688.     CloseAll();
  689.     exit(0);
  690. }
  691.  
  692.  
  693.  
  694.  
  695.